const express = require('express');
const marked = require('marked');
const mongoose = require('mongoose');
const check = require('../models/check');

const UserModel = mongoose.model('users');
const ArticleModel = mongoose.model('article');
const MessageModel = mongoose.model('message');

const router = express.Router();


// 点击头像展示 特定作者的所有文章summary方式展示
router.get('/author=:author&page=:pagenumber', check.NeedLogin, (req, res) => { // 此处路由所使用的正则表达式和js默认的方式所展现的情况似乎不同 
  const reqauthor = req.params.author; // 从路由中获取author= 后面的参数
  const pagenumber = req.params.pagenumber;

  /** test */
  // ArticleModel.count({}, (err, count) => {
  //   if (err) { console.error('home.js:ArticleModel.count:error'); return res.redirect('back'); }
  //   ArticleModel // module.paging(find, populate, pagenumber, skip, limit)
  //     .paging({}, { path: 'author', select: 'name icon profile' }, req.params.pagenumber - 1, 10, 10)
  //     .then(
  //       (recdata) => {
  //         try {
  //           if (!recdata) throw new Error('至今为止还没有任何文章被发表');
  //         } catch (e) {
  //           req.flash('error', e.message);
  //           return res.redirect('/');
  //         }
  //         if (recdata) {
  //         // 在已经确定有文章被发表的情况下，根据每篇文章的作者索取该作者的头像icon，然后添加到所返回的articles中，为文章缩略页的每篇文章提供头像
  //           const renderdata = [];
  //           let i = 0;
  //           recdata.forEach((data) => {
  //             renderdata[i] = {
  //               name: data.author.name,
  //               icon: data.author.icon,
  //               profile: data.author.profile,
  //               _id: data._id,
  //               title: data.title,
  //               summary: data.summary,
  //               content: data.content,
  //             };
  //             i += 1;
  //           });
  //           res.render('article_index', { res: renderdata, page: count / 10 });
  //         }
  //       },
  //     );
  // });
  /** test */

  /** test2 */
  // 根据作者账号寻找作者的所有相关信息
  UserModel // module.paging(find, populate, pagenumber, skip, limit );
  // .paging({ name: reqauthor }, { path: 'articles', select: 'title summary content' }, pagenumber - 1, 10, 10)
    .findOne({ name: reqauthor })
    .populate({ path: 'articles', select: 'title summary content' })
    .then((recdata) => {
      try {
        if (!recdata) throw new Error('该作者未曾发表文章');
      } catch (e) {
        req.flash('error', e.message);
        return res.redirect('/');
      }
      if (recdata) {
        const renderdata = [];
        let i = 0;
        recdata.articles.forEach((data) => { // 把获取到users数据转换成数组形式
          /**
             * 原来是 {name：‘xx’,
             *        icon: 'xxx', 
             *        articles:[
             *                   {title:'xx',summary:'xxx'}
             *                   {title:'xx',summary:'xxx'}
             *                   {title:'xx',summary:'xxx'}
             *                  ]
             *       }
             * 现在是 renderdata = [
             *                      {name:'xx',icon:'xx',title:'xx',summary:'xxx'}
             *                      {name:'xx',icon:'xx',title:'xx',summary:'xxx'}
             *                    ]  
             *  为的是统一渲染网页的数据形式 
             */
          renderdata[i] = {
            name: reqauthor,
            icon: recdata.icon,
            profile: recdata.profile,
            _id: data._id,
            title: data.title,
            summary: data.summary,
            content: data.content,
          };
          i += 1;
        });
        const page = Math.ceil(i / 10); // 0.9->0  1.1->2
        const up = (parseInt(pagenumber, 10) - 1) * 10;
        const down = (parseInt(pagenumber, 10)) * 10;
        res.render('article_author', { res: renderdata.reverse().slice(up, down), page });
      }
    });
  /** test2 */
});

// 根据文章存储自动生成的_id 来寻找文章  主要用于发表完文章后自动跳转到已发表文章页
router.get('/id=*', check.NeedLogin, (req, res) => { // 此处路由所使用的正则表达式和js默认的方式所展现的情况似乎不同 
  if (req.params[0].length !== 24) {
    req.flash('error', '没有找到此篇文章');
    return res.redirect('/index=1');
  }
  ArticleModel
    .findOne({ _id: req.params[0] })
    .populate({ path: 'author', select: 'name icon profile' })
    .then((recdata) => {
      try {
        if (!recdata) throw new Error('链接文章失败：没有找到该文章');
      } catch (e) {
        req.flash('error', e.message);
        return res.redirect('/index=1');
      }
      if (recdata) {
        MessageModel
          .find({ belongarticle: req.params[0] })
          .populate({ path: 'mesauthor', select: 'icon name' })
          .then((recdata2) => {
            const messages = [];
            let i = 0;
            recdata2.forEach((message) => {
              messages[i] = { // 有一个疑问，为什么必须用大括号的形式，而不能使用分开赋值的方式：message[i].mesicon:message.mesauthor.iocn; message[i].mescontent: message.mescontent,
                mesicon: message.mesauthor.icon,
                mescontent: message.mescontent,
                mesauthor: message.mesauthor.name,
              };
              i += 1;
            });

            const renderdata = {
              name: recdata.author.name,
              icon: recdata.author.icon,
              profile: recdata.author.profile,
              title: recdata.title,
              summary: recdata.summary,
              content: recdata.content,
            };
            res.render('article_id', {
              res: renderdata,
              message: messages,
            });
          });
      }
    });
});

// 文章发表 接受提交的文章数据并在校验后存储到数据库
router.post('/', check.NeedLogin, (req, res) => {
  const article = {
    author: req.session.user._id,
    title: req.fields.title,
    summary: req.fields.summary,
    content: marked(req.fields.content),
  };
  //   author: { type: mongoose.Schema.Types.Object, ref: 'users' }, // 待修改
  //   title: { type: 'string' },
  //   summary: { type: 'string' },
  //   content: { type: 'string' }, // 内容
  //   messages: [{ type: mongoose.Schema.Types.Object, ref: 'message' }],
  //   date: { type: Date, default: Date.now },
  //   pv: { type: 'number' },
  try {
    if (!article.title) throw new Error('未填写标题');
    if (!article.summary) throw new Error('未填写摘要');
    if (!article.content) throw new Error('未填写正文内容');
  } catch (error) {
    req.flash('error', error.message);
    // return res.redirect(`/article/author=${req.session.user.name}`);
    return res.redirect('back'); // 没有正确提交文章信息时返回发表文章之前的页面
  }

  ArticleModel
    .create(article)
    .then(
      (recdata) => {
        req.flash('success', '文章发表成功');
        UserModel
        // 根据当前用户也就是发表文章的用户的_id查找到该用户的document，并在其document中的articles里添加此次被发表的文章的_id；
        // 由于一个用户可能发表多篇文档，所以用户的articles是一个数组，故用$addToSet为其更新数据
          .update({ _id: req.session.user._id }, { $addToSet: { articles: recdata._id } })
          .then(rec => console.log(rec)); // 这一句没有了上一句就不能更新，我也不知道为什么，另外rec的结果也有点匪夷所思，需要假以时日认真读mongoose的API
        return res.redirect(`/article/id=${recdata._id}`);
      },
    );
});

module.exports = router;
